Please address the comments from this code review:

## Overall Comments
- RunCleanAccountAdvisory always logs `task performed successfully` even if one or both cleaners fail; consider aggregating error results and surfacing a non-success log or exit status when any delete operation returns an error.
- CleanAdvisoryAccountData and CleanAccountAdvisory share nearly identical transaction and logging logic; consider extracting a small helper that accepts the model and condition to reduce duplication and keep the behavior consistent across both tables.

Please address the comments from this code review:

## Overall Comments
- The `CleanAdvisoryAccountData` and `CleanAccountAdvisory` functions are nearly identical; consider extracting a shared helper that takes the model type/table name to reduce duplication and keep the cleanup logic consistent in one place.
- In both cleanup functions you call `Begin()` with `defer tx.Rollback()` and then `tx.Commit()` without checking its error; consider either using the base DB without an explicit transaction for this single-statement delete, or handling `Commit()` errors explicitly and avoiding a deferred rollback after a successful commit.

## Individual Comments

### Comment 1
<location path="tasks/cleaning/clean_account_advisory.go" line_range="11-20" />
<code_context>
+	"sync"
+)
+
+func RunCleanAccountAdvisory() {
+	tasks.HandleContextCancel(tasks.WaitAndExit)
+	core.ConfigureApp()
+	defer utils.LogPanics(true)
+
+	var wg sync.WaitGroup
+	wg.Add(2)
+
+	go func() {
+		defer wg.Done()
+		utils.LogInfo("Deleting advisory rows with 0 applicable/installable systems from advisory_account_data")
+		if err := CleanAdvisoryAccountData(); err != nil {
+			utils.LogError("err", err, "Cleaning advisory_account_data")
+		}
+	}()
+
+	go func() {
+		defer wg.Done()
+		utils.LogInfo("Deleting advisory rows with 0 applicable/installable systems from account_advisory")
+		if err := CleanAccountAdvisory(); err != nil {
+			utils.LogError("err", err, "Cleaning account_advisory")
+		}
+	}()
+
+	wg.Wait()
+	utils.LogInfo("RunCleanAccountAdvisory task performed successfully")
+}
+
</code_context>
<issue_to_address>
**issue (bug_risk):** Consider surfacing failures from the two cleanup routines instead of always logging success

Right now, errors from `CleanAdvisoryAccountData` / `CleanAccountAdvisory` are only logged inside the goroutines, but `RunCleanAccountAdvisory` still logs a blanket success message. This can misrepresent job status and interfere with alerting. Consider aggregating errors (e.g., via a channel or shared error with synchronization) so that you can emit a failure log when any cleanup fails and optionally exit with a non-zero status for the job runner.
</issue_to_address>

### Comment 2
<location path="tasks/cleaning/clean_account_advisory.go" line_range="39-48" />
<code_context>
+	utils.LogInfo("RunCleanAccountAdvisory task performed successfully")
+}
+
+func CleanAdvisoryAccountData() error {
+	tx := tasks.CancelableDB().Begin()
+	defer tx.Rollback()
+
+	result := tx.Delete(&models.AdvisoryAccountData{}, "systems_installable <= 0 AND systems_applicable <= 0")
+	if result.Error != nil {
+		return result.Error
+	}
+
+	tx.Commit()
+	utils.LogInfo("nDeleted", result.RowsAffected, "advisory_account_data cleaned successfully")
+	return nil
</code_context>
<issue_to_address>
**issue (bug_risk):** Avoid deferring Rollback after a successful Commit and check Commit errors

With `Begin` + `defer tx.Rollback()` + `tx.Commit()`, `Rollback` still runs after `Commit`, which can generate spurious errors/logs depending on the driver, and `Commit` errors are currently ignored.

Prefer an explicit pattern that:
- Checks `Begin` error
- Uses `defer` only for panic recovery
- Rolls back on intermediate errors
- Checks and returns the `Commit` error

For example:

```go
func CleanAdvisoryAccountData() error {
    tx := tasks.CancelableDB().Begin()
    if tx.Error != nil {
        return tx.Error
    }

    defer func() {
        if r := recover(); r != nil {
            tx.Rollback()
            panic(r)
        }
    }()

    result := tx.Delete(&models.AdvisoryAccountData{}, "systems_installable <= 0 AND systems_applicable <= 0")
    if result.Error != nil {
        tx.Rollback()
        return result.Error
    }

    if err := tx.Commit().Error; err != nil {
        return err
    }

    utils.LogInfo("nDeleted", result.RowsAffected, "advisory_account_data cleaned successfully")
    return nil
}
```

Same fix applies to `CleanAccountAdvisory()`.
</issue_to_address>